home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1994 November: Tool Chest / Dev.CD Nov 94.toast / Tool Chest / !Interfaces / Universal Interfaces 2.0a1 / CIncludes / MacTCP.h < prev    next >
Encoding:
C/C++ Source or Header  |  1994-07-17  |  25.9 KB  |  1,014 lines  |  [TEXT/MPS ]
  1. /*
  2.      File:        MacTCP.h
  3.  
  4.      Copyright:    © 1984-1994 by Apple Computer, Inc.
  5.                  All rights reserved.
  6.  
  7.      Version:    Universal Interfaces 2.0a1.  ETO #15, MPW prerelease.  Sunday, July 17, 1994. 
  8.  
  9.      Bugs?:        If you find a problem with this file, send the file and version
  10.                  information (from above) and the problem description to:
  11.  
  12.                      Internet:    apple.bugs@applelink.apple.com
  13.                      AppleLink:    APPLE.BUGS
  14.  
  15. */
  16.  
  17. #ifndef __MACTCP__
  18. #define __MACTCP__
  19.  
  20.  
  21. #ifndef __TYPES__
  22. #include <Types.h>
  23. #endif
  24. /*    #include <ConditionalMacros.h>                                */
  25.  
  26. #ifndef __APPLETALK__
  27. #include <AppleTalk.h>
  28. #endif
  29. /*    #include <OSUtils.h>                                        */
  30. /*        #include <MixedMode.h>                                    */
  31.  
  32. #ifdef __cplusplus
  33. extern "C" {
  34. #endif
  35.  
  36. #if GENERATINGPOWERPC
  37. #pragma options align=mac68k
  38. #endif
  39.  
  40. #ifdef __CFM68K__
  41. #pragma lib_export on
  42. #endif
  43.  
  44.  
  45. enum {
  46.     inProgress                    = 1,                            /* I/O in progress */
  47.     ipBadLapErr                    = -23000,                        /* bad network configuration */
  48.     ipBadCnfgErr                = -23001,                        /* bad IP configuration error */
  49.     ipNoCnfgErr                    = -23002,                        /* missing IP or LAP configuration error */
  50.     ipLoadErr                    = -23003,                        /* error in MacTCP load */
  51.     ipBadAddr                    = -23004,                        /* error in getting address */
  52.     connectionClosing            = -23005,                        /* connection is closing */
  53.     invalidLength                = -23006,
  54.     connectionExists            = -23007,                        /* request conflicts with existing connection */
  55.     connectionDoesntExist        = -23008,                        /* connection does not exist */
  56.     insufficientResources        = -23009,                        /* insufficient resources to perform request */
  57.     invalidStreamPtr            = -23010,
  58.     streamAlreadyOpen            = -23011,
  59.     connectionTerminated        = -23012,
  60.     invalidBufPtr                = -23013,
  61.     invalidRDS                    = -23014,
  62.     invalidWDS                    = -23014,
  63.     openFailed                    = -23015,
  64.     commandTimeout                = -23016,
  65.     duplicateSocket                = -23017
  66. };
  67.  
  68. /* Error codes from internal IP functions */
  69. enum {
  70.     ipDontFragErr                = -23032,                        /* Packet too large to send w/o fragmenting */
  71.     ipDestDeadErr                = -23033,                        /* destination not responding */
  72.     icmpEchoTimeoutErr            = -23035,                        /* ICMP echo timed-out */
  73.     ipNoFragMemErr                = -23036,                        /* no memory to send fragmented pkt */
  74.     ipRouteErr                    = -23037,                        /* can't route packet off-net */
  75.     nameSyntaxErr                = -23041,
  76.     cacheFault                    = -23042,
  77.     noResultProc                = -23043,
  78.     noNameServer                = -23044,
  79.     authNameErr                    = -23045,
  80.     noAnsErr                    = -23046,
  81.     dnrErr                        = -23047,
  82.     outOfMemory                    = -23048
  83. };
  84.  
  85. enum {
  86.     BYTES_16WORD                = 2,                            /* bytes per = 16, bit ip word */
  87.     BYTES_32WORD                = 4,                            /* bytes per = 32, bit ip word */
  88.     BYTES_64WORD                = 8                                /* bytes per = 64, bit ip word */
  89. };
  90.  
  91. typedef unsigned char b_8;
  92.  
  93. typedef unsigned short b_16;
  94.  
  95. typedef unsigned long b_32;
  96.  
  97. typedef b_32 ip_addr;
  98.  
  99. struct ip_addrbytes {
  100.         union {
  101.             b_32                            addr;
  102.             char                            byte[4];
  103.         }                            a;
  104. };
  105. typedef struct ip_addrbytes ip_addrbytes;
  106.  
  107. struct wdsEntry {
  108.     unsigned short                    length;                        /* length of buffer */
  109.     char                            *ptr;                        /* pointer to buffer */
  110. };
  111. typedef struct wdsEntry wdsEntry;
  112.  
  113. struct rdsEntry {
  114.     unsigned short                    length;                        /* length of buffer */
  115.     char                            *ptr;                        /* pointer to buffer */
  116. };
  117. typedef struct rdsEntry rdsEntry;
  118.  
  119. typedef unsigned long BufferPtr;
  120.  
  121. typedef unsigned long StreamPtr;
  122.  
  123.  
  124. enum {
  125.     netUnreach                    = 0,
  126.     hostUnreach                    = 1,
  127.     protocolUnreach                = 2,
  128.     portUnreach                    = 3,
  129.     fragReqd                    = 4,
  130.     sourceRouteFailed            = 5,
  131.     timeExceeded                = 6,
  132.     parmProblem                    = 7,
  133.     missingOption                = 8
  134. };
  135.  
  136. typedef unsigned short ICMPMsgType;
  137.  
  138. typedef b_16 ip_port;
  139.  
  140. struct ICMPReport {
  141.     StreamPtr                        streamPtr;
  142.     ip_addr                            localHost;
  143.     ip_port                            localPort;
  144.     ip_addr                            remoteHost;
  145.     ip_port                            remotePort;
  146.     short                            reportType;
  147.     unsigned short                    optionalAddlInfo;
  148.     unsigned long                    optionalAddlInfoPtr;
  149. };
  150. typedef struct ICMPReport ICMPReport;
  151.  
  152. typedef OSErr (*OSErrProcPtr)();
  153.  
  154. #if GENERATINGCFM
  155. typedef UniversalProcPtr OSErrUPP;
  156. #else
  157. typedef OSErrProcPtr OSErrUPP;
  158. #endif
  159.  
  160. enum {
  161.     uppOSErrProcInfo = kCStackBased
  162.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  163. };
  164.  
  165. #if GENERATINGCFM
  166. #define NewOSErrProc(userRoutine)        \
  167.         (OSErrUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppOSErrProcInfo, GetCurrentArchitecture())
  168. #else
  169. #define NewOSErrProc(userRoutine)        \
  170.         ((OSErrUPP) (userRoutine))
  171. #endif
  172.  
  173. #if GENERATINGCFM
  174. #define CallOSErrProc(userRoutine)        \
  175.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppOSErrProcInfo)
  176. #else
  177. #define CallOSErrProc(userRoutine)        \
  178.         (*(userRoutine))()
  179. #endif
  180.  
  181. typedef Ptr (*PtrProcPtr)();
  182.  
  183. #if GENERATINGCFM
  184. typedef UniversalProcPtr PtrUPP;
  185. #else
  186. typedef PtrProcPtr PtrUPP;
  187. #endif
  188.  
  189. enum {
  190.     uppPtrProcInfo = kCStackBased
  191.          | RESULT_SIZE(SIZE_CODE(sizeof(Ptr)))
  192. };
  193.  
  194. #if GENERATINGCFM
  195. #define NewPtrProc(userRoutine)        \
  196.         (PtrUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppPtrProcInfo, GetCurrentArchitecture())
  197. #else
  198. #define NewPtrProc(userRoutine)        \
  199.         ((PtrUPP) (userRoutine))
  200. #endif
  201.  
  202. #if GENERATINGCFM
  203. #define CallPtrProc(userRoutine)        \
  204.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppPtrProcInfo)
  205. #else
  206. #define CallPtrProc(userRoutine)        \
  207.         (*(userRoutine))()
  208. #endif
  209.  
  210. typedef Boolean (*BooleanProcPtr)();
  211.  
  212. #if GENERATINGCFM
  213. typedef UniversalProcPtr BooleanUPP;
  214. #else
  215. typedef BooleanProcPtr BooleanUPP;
  216. #endif
  217.  
  218. enum {
  219.     uppBooleanProcInfo = kCStackBased
  220.          | RESULT_SIZE(SIZE_CODE(sizeof(Boolean)))
  221. };
  222.  
  223. #if GENERATINGCFM
  224. #define NewBooleanProc(userRoutine)        \
  225.         (BooleanUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppBooleanProcInfo, GetCurrentArchitecture())
  226. #else
  227. #define NewBooleanProc(userRoutine)        \
  228.         ((BooleanUPP) (userRoutine))
  229. #endif
  230.  
  231. #if GENERATINGCFM
  232. #define CallBooleanProc(userRoutine)        \
  233.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppBooleanProcInfo)
  234. #else
  235. #define CallBooleanProc(userRoutine)        \
  236.         (*(userRoutine))()
  237. #endif
  238.  
  239.  
  240. enum {
  241.     NUM_ALT_ADDRS                = 4
  242. };
  243.  
  244. struct hostInfo {
  245.     long                            rtnCode;
  246.     char                            cname[255];
  247.     UInt8                            filler;                        /* Filler for proper byte alignment     */
  248.     unsigned long                    addr[NUM_ALT_ADDRS];
  249. };
  250. typedef struct hostInfo hostInfo;
  251.  
  252.  
  253. enum {
  254.     A                            = 1,
  255.     NS                            = 2,
  256.     CNAME                        = 5,
  257.     HINFO                        = 13,
  258.     MX                            = 15
  259. };
  260.  
  261. typedef unsigned short AddrClasses;
  262.  
  263. struct HInfoRec {
  264.     char                            cpuType[30];
  265.     char                            osType[30];
  266. };
  267. typedef struct HInfoRec HInfoRec;
  268.  
  269. struct MXRec {
  270.     unsigned short                    preference;
  271.     char                            exchange[255];
  272. };
  273. typedef struct MXRec MXRec;
  274.  
  275. struct returnRec {
  276.     long                            rtnCode;
  277.     char                            cname[255];
  278.     UInt8                            filler;                        /* Filler for proper byte alignment     */
  279.         union {
  280.             unsigned long                    addr[NUM_ALT_ADDRS];
  281.             struct HInfoRec                    hinfo;
  282.             struct MXRec                    mx;
  283.         }                            rdata;
  284. };
  285. struct cacheEntryRecord {
  286.     char                            *cname;
  287.     unsigned short                    ctype;
  288.     unsigned short                    cacheClass;
  289.     unsigned long                    ttl;
  290.         union {
  291.             char                            *name;
  292.             ip_addr                            addr;
  293.         }                            rdata;
  294. };
  295. typedef struct returnRec returnRec;
  296.  
  297. typedef struct cacheEntryRecord cacheEntryRecord;
  298.  
  299. typedef pascal void (*EnumResultProcPtr)(struct cacheEntryRecord *cacheEntryRecordPtr, char *userDataPtr);
  300.  
  301. #if GENERATINGCFM
  302. typedef UniversalProcPtr EnumResultUPP;
  303. #else
  304. typedef EnumResultProcPtr EnumResultUPP;
  305. #endif
  306.  
  307. enum {
  308.     uppEnumResultProcInfo = kPascalStackBased
  309.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(struct cacheEntryRecord*)))
  310.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(char*)))
  311. };
  312.  
  313. #if GENERATINGCFM
  314. #define NewEnumResultProc(userRoutine)        \
  315.         (EnumResultUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppEnumResultProcInfo, GetCurrentArchitecture())
  316. #else
  317. #define NewEnumResultProc(userRoutine)        \
  318.         ((EnumResultUPP) (userRoutine))
  319. #endif
  320.  
  321. #if GENERATINGCFM
  322. #define CallEnumResultProc(userRoutine, cacheEntryRecordPtr, userDataPtr)        \
  323.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppEnumResultProcInfo, (cacheEntryRecordPtr), (userDataPtr))
  324. #else
  325. #define CallEnumResultProc(userRoutine, cacheEntryRecordPtr, userDataPtr)        \
  326.         (*(userRoutine))((cacheEntryRecordPtr), (userDataPtr))
  327. #endif
  328.  
  329. typedef pascal void (*ResultProcPtr)(struct hostInfo *hostInfoPtr, char *userDataPtr);
  330.  
  331. #if GENERATINGCFM
  332. typedef UniversalProcPtr ResultUPP;
  333. #else
  334. typedef ResultProcPtr ResultUPP;
  335. #endif
  336.  
  337. enum {
  338.     uppResultProcInfo = kPascalStackBased
  339.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(struct hostInfo*)))
  340.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(char*)))
  341. };
  342.  
  343. #if GENERATINGCFM
  344. #define NewResultProc(userRoutine)        \
  345.         (ResultUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppResultProcInfo, GetCurrentArchitecture())
  346. #else
  347. #define NewResultProc(userRoutine)        \
  348.         ((ResultUPP) (userRoutine))
  349. #endif
  350.  
  351. #if GENERATINGCFM
  352. #define CallResultProc(userRoutine, hostInfoPtr, userDataPtr)        \
  353.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppResultProcInfo, (hostInfoPtr), (userDataPtr))
  354. #else
  355. #define CallResultProc(userRoutine, hostInfoPtr, userDataPtr)        \
  356.         (*(userRoutine))((hostInfoPtr), (userDataPtr))
  357. #endif
  358.  
  359. typedef pascal void (*Result2ProcPtr)(struct returnRec *returnRecPtr, char *userDataPtr);
  360.  
  361. #if GENERATINGCFM
  362. typedef UniversalProcPtr Result2UPP;
  363. #else
  364. typedef Result2ProcPtr Result2UPP;
  365. #endif
  366.  
  367. enum {
  368.     uppResult2ProcInfo = kPascalStackBased
  369.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(struct returnRec*)))
  370.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(char*)))
  371. };
  372.  
  373. #if GENERATINGCFM
  374. #define NewResult2Proc(userRoutine)        \
  375.         (Result2UPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppResult2ProcInfo, GetCurrentArchitecture())
  376. #else
  377. #define NewResult2Proc(userRoutine)        \
  378.         ((Result2UPP) (userRoutine))
  379. #endif
  380.  
  381. #if GENERATINGCFM
  382. #define CallResult2Proc(userRoutine, returnRecPtr, userDataPtr)        \
  383.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppResult2ProcInfo, (returnRecPtr), (userDataPtr))
  384. #else
  385. #define CallResult2Proc(userRoutine, returnRecPtr, userDataPtr)        \
  386.         (*(userRoutine))((returnRecPtr), (userDataPtr))
  387. #endif
  388.  
  389. extern pascal OSErr OpenResolver(char *fileName);
  390. extern pascal OSErr StrToAddr(char *hostName, struct hostInfo *hostInfoPtr, ResultUPP ResultProc, char *userDataPtr);
  391. extern pascal OSErr AddrToStr(unsigned long addr, char *addrStr);
  392. extern pascal OSErr EnumCache(EnumResultUPP enumResultProc, char *userDataPtr);
  393. extern pascal OSErr AddrToName(ip_addr addr, struct hostInfo *hostInfoPtr, ResultUPP ResultProc, char *userDataPtr);
  394. extern pascal OSErr HInfo(char *hostName, struct returnRec *returnRecPtr, Result2UPP resultProc, char *userDataPtr);
  395. extern pascal OSErr MXInfo(char *hostName, struct returnRec *returnRecPtr, Result2UPP resultProc, char *userDataPtr);
  396. extern pascal OSErr CloseResolver(void);
  397. /* csCode to get our IP address */
  398.  
  399. enum {
  400.     ipctlGetAddr                = 15
  401. };
  402.  
  403. struct GetAddrParamBlock {
  404.     struct QElem                    *qLink;
  405.     short                            qType;
  406.     short                            ioTrap;
  407.     Ptr                                ioCmdAddr;
  408.     UniversalProcPtr                ioCompletion;
  409.     OSErr                            ioResult;
  410.     StringPtr                        ioNamePtr;
  411.     short                            ioVRefNum;
  412.     short                            ioCRefNum;
  413.     short                            csCode;                        /* standard I/O header */
  414.     ip_addr                            ourAddress;                    /* our IP address */
  415.     long                            ourNetMask;                    /* our IP net mask */
  416. };
  417. typedef struct GetAddrParamBlock GetAddrParamBlock;
  418.  
  419. /* control codes */
  420.  
  421. enum {
  422.     ipctlEchoICMP                = 17,                            /* send icmp echo */
  423.     ipctlLAPStats                = 19                            /* get lap stats */
  424. };
  425.  
  426. struct ICMPParamBlock {
  427.     struct QElem                    *qLink;
  428.     short                            qType;
  429.     short                            ioTrap;
  430.     Ptr                                ioCmdAddr;
  431.     UniversalProcPtr                ioCompletion;
  432.     OSErr                            ioResult;
  433.     StringPtr                        ioNamePtr;
  434.     short                            ioVRefNum;
  435.     short                            ioCRefNum;
  436.     short                            csCode;                        /* standard I/O header */
  437.     short                            params[11];
  438.         struct {
  439.             unsigned long                    echoRequestOut;        /* time in ticks of when the echo request went out */
  440.             unsigned long                    echoReplyIn;        /* time in ticks of when the reply was received */
  441.             struct rdsEntry                    echoedData;            /* data received in responce */
  442.             Ptr                                options;
  443.             unsigned long                    userDataPtr;
  444.         }                            icmpEchoInfo;
  445. };
  446.  
  447. enum {
  448.     NBP_TABLE_SIZE                = 20,                            /* number of NBP table entries */
  449.     NBP_MAX_NAME_SIZE            = 16 + 10 + 2
  450. };
  451.  
  452. struct nbp_entry {
  453.     ip_addr                            ip_address;                    /* IP address */
  454.     AddrBlock                        at_address;                    /* matching AppleTalk address */
  455.     Boolean                            gateway;                    /* TRUE if entry for a gateway */
  456.     Boolean                            valid;                        /* TRUE if LAP address is valid */
  457.     Boolean                            probing;                    /* TRUE if NBP lookup pending */
  458.     UInt8                            afiller;                    /* Filler for proper byte alignment     */
  459.     long                            age;                        /* ticks since cache entry verified */
  460.     long                            access;                        /* ticks since last access */
  461.     char                            filler[116];                /* for internal use only !!! */
  462. };
  463. /* number of ARP table entries */
  464.  
  465. enum {
  466.     ARP_TABLE_SIZE                = 20
  467. };
  468.  
  469. struct Enet_addr {
  470.     b_16                            en_hi;
  471.     b_32                            en_lo;
  472. };
  473. typedef struct Enet_addr Enet_addr;
  474.  
  475. struct arp_entry {
  476.     short                            age;                        /* cache aging field */
  477.     b_16                            protocol;                    /* Protocol type */
  478.     ip_addr                            ip_address;                    /* IP address */
  479.     Enet_addr                        en_address;                    /* matching Ethernet address */
  480. };
  481. typedef struct arp_entry arp_entry;
  482.  
  483. /* Command codes */
  484.  
  485. enum {
  486.     TCPCreate                    = 30,
  487.     TCPPassiveOpen                = 31,
  488.     TCPActiveOpen                = 32,
  489.     TCPSend                        = 34,
  490.     TCPNoCopyRcv                = 35,
  491.     TCPRcvBfrReturn                = 36,
  492.     TCPRcv                        = 37,
  493.     TCPClose                    = 38,
  494.     TCPAbort                    = 39,
  495.     TCPStatus                    = 40,
  496.     TCPExtendedStat                = 41,
  497.     TCPRelease                    = 42,
  498.     TCPGlobalInfo                = 43,
  499.     TCPCtlMax                    = 49
  500. };
  501.  
  502. typedef void (*ICMPEchoNotifyProcPtr)(struct ICMPParamBlock *iopb);
  503.  
  504. #if GENERATINGCFM
  505. typedef UniversalProcPtr ICMPEchoNotifyUPP;
  506. #else
  507. typedef ICMPEchoNotifyProcPtr ICMPEchoNotifyUPP;
  508. #endif
  509.  
  510. enum {
  511.     uppICMPEchoNotifyProcInfo = kCStackBased
  512.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(struct ICMPParamBlock*)))
  513. };
  514.  
  515. #if GENERATINGCFM
  516. #define NewICMPEchoNotifyProc(userRoutine)        \
  517.         (ICMPEchoNotifyUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppICMPEchoNotifyProcInfo, GetCurrentArchitecture())
  518. #else
  519. #define NewICMPEchoNotifyProc(userRoutine)        \
  520.         ((ICMPEchoNotifyUPP) (userRoutine))
  521. #endif
  522.  
  523. #if GENERATINGCFM
  524. #define CallICMPEchoNotifyProc(userRoutine, iopb)        \
  525.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppICMPEchoNotifyProcInfo, (iopb))
  526. #else
  527. #define CallICMPEchoNotifyProc(userRoutine, iopb)        \
  528.         (*(userRoutine))((iopb))
  529. #endif
  530.  
  531. struct IPParamBlock {
  532.     struct QElem                    *qLink;
  533.     short                            qType;
  534.     short                            ioTrap;
  535.     Ptr                                ioCmdAddr;
  536.     UniversalProcPtr                ioCompletion;
  537.     OSErr                            ioResult;
  538.     StringPtr                        ioNamePtr;
  539.     short                            ioVRefNum;
  540.     short                            ioCRefNum;
  541.     short                            csCode;                        /* standard I/O header */
  542.         union {
  543.                 struct {
  544.                     ip_addr                            dest;        /* echo to IP address */
  545.                     wdsEntry                        data;
  546.                     short                            timeout;
  547.                     Ptr                                options;
  548.                     unsigned short                    optLength;
  549.                     ICMPEchoNotifyUPP                icmpCompletion;
  550.                     unsigned long                    userDataPtr;
  551.                 }                            IPEchoPB;
  552.                 struct {
  553.                     struct LAPStats                    *lapStatsPtr;
  554.                 }                            LAPStatsPB;
  555.         }                            csParam;
  556. };
  557. struct LAPStats {
  558.     short                            ifType;
  559.     char                            *ifString;
  560.     short                            ifMaxMTU;
  561.     long                            ifSpeed;
  562.     short                            ifPhyAddrLength;
  563.     char                            *ifPhysicalAddress;
  564.         union {
  565.             struct arp_entry                *arp_table;
  566.             struct nbp_entry                *nbp_table;
  567.         }                            AddrXlation;
  568.     short                            slotNumber;
  569. };
  570. typedef struct LAPStats LAPStats;
  571.  
  572.  
  573. enum {
  574.     TCPClosing                    = 1,
  575.     TCPULPTimeout                = 2,
  576.     TCPTerminate                = 3,
  577.     TCPDataArrival                = 4,
  578.     TCPUrgent                    = 5,
  579.     TCPICMPReceived                = 6
  580. };
  581.  
  582. typedef unsigned short TCPEventCode;
  583.  
  584.  
  585. enum {
  586.     TCPRemoteAbort                = 2,
  587.     TCPNetworkFailure            = 3,
  588.     TCPSecPrecMismatch            = 4,
  589.     TCPULPTimeoutTerminate        = 5,
  590.     TCPULPAbort                    = 6,
  591.     TCPULPClose                    = 7,
  592.     TCPServiceError                = 8
  593. };
  594.  
  595. typedef unsigned short TCPTerminationReason;
  596.  
  597. typedef pascal void (*TCPNotifyProcPtr)(StreamPtr tcpStream, unsigned short eventCode, Ptr userDataPtr, unsigned short terminReason, struct ICMPReport *icmpMsg);
  598.  
  599. #if GENERATINGCFM
  600. typedef UniversalProcPtr TCPNotifyUPP;
  601. #else
  602. typedef TCPNotifyProcPtr TCPNotifyUPP;
  603. #endif
  604.  
  605. enum {
  606.     uppTCPNotifyProcInfo = kPascalStackBased
  607.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(StreamPtr)))
  608.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(unsigned short)))
  609.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(Ptr)))
  610.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(unsigned short)))
  611.          | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(struct ICMPReport*)))
  612. };
  613.  
  614. #if GENERATINGCFM
  615. #define NewTCPNotifyProc(userRoutine)        \
  616.         (TCPNotifyUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppTCPNotifyProcInfo, GetCurrentArchitecture())
  617. #else
  618. #define NewTCPNotifyProc(userRoutine)        \
  619.         ((TCPNotifyUPP) (userRoutine))
  620. #endif
  621.  
  622. #if GENERATINGCFM
  623. #define CallTCPNotifyProc(userRoutine, tcpStream, eventCode, userDataPtr, terminReason, icmpMsg)        \
  624.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppTCPNotifyProcInfo, (tcpStream), (eventCode), (userDataPtr), (terminReason), (icmpMsg))
  625. #else
  626. #define CallTCPNotifyProc(userRoutine, tcpStream, eventCode, userDataPtr, terminReason, icmpMsg)        \
  627.         (*(userRoutine))((tcpStream), (eventCode), (userDataPtr), (terminReason), (icmpMsg))
  628. #endif
  629.  
  630. typedef unsigned short tcp_port;
  631.  
  632. /* ValidityFlags */
  633.  
  634. enum {
  635.     timeoutValue                = 0x80,
  636.     timeoutAction                = 0x40,
  637.     typeOfService                = 0x20,
  638.     precedence                    = 0x10
  639. };
  640.  
  641. /* TOSFlags */
  642. enum {
  643.     lowDelay                    = 0x01,
  644.     throughPut                    = 0x02,
  645.     reliability                    = 0x04
  646. };
  647.  
  648. struct TCPCreatePB {
  649.     Ptr                                rcvBuff;
  650.     unsigned long                    rcvBuffLen;
  651.     TCPNotifyUPP                    notifyProc;
  652.     Ptr                                userDataPtr;
  653. };
  654. typedef struct TCPCreatePB TCPCreatePB;
  655.  
  656. struct TCPOpenPB {
  657.     SInt8                            ulpTimeoutValue;
  658.     SInt8                            ulpTimeoutAction;
  659.     SInt8                            validityFlags;
  660.     SInt8                            commandTimeoutValue;
  661.     ip_addr                            remoteHost;
  662.     tcp_port                        remotePort;
  663.     ip_addr                            localHost;
  664.     tcp_port                        localPort;
  665.     SInt8                            tosFlags;
  666.     SInt8                            precedence;
  667.     Boolean                            dontFrag;
  668.     SInt8                            timeToLive;
  669.     SInt8                            security;
  670.     SInt8                            optionCnt;
  671.     SInt8                            options[40];
  672.     Ptr                                userDataPtr;
  673. };
  674. typedef struct TCPOpenPB TCPOpenPB;
  675.  
  676. struct TCPSendPB {
  677.     SInt8                            ulpTimeoutValue;
  678.     SInt8                            ulpTimeoutAction;
  679.     SInt8                            validityFlags;
  680.     UInt8                            filler;                        /* Filler for proper byte alignment     */
  681.     Boolean                            pushFlag;
  682.     Boolean                            urgentFlag;
  683.     Ptr                                wdsPtr;
  684.     unsigned long                    sendFree;
  685.     unsigned short                    sendLength;
  686.     Ptr                                userDataPtr;
  687. };
  688. typedef struct TCPSendPB TCPSendPB;
  689.  
  690. /* for receive and return rcv buff calls */
  691. struct TCPReceivePB {
  692.     SInt8                            commandTimeoutValue;
  693.     SInt8                            filler;
  694.     Boolean                            markFlag;
  695.     Boolean                            urgentFlag;
  696.     Ptr                                rcvBuff;
  697.     unsigned short                    rcvBuffLen;
  698.     Ptr                                rdsPtr;
  699.     unsigned short                    rdsLength;
  700.     unsigned short                    secondTimeStamp;
  701.     Ptr                                userDataPtr;
  702. };
  703. typedef struct TCPReceivePB TCPReceivePB;
  704.  
  705. struct TCPClosePB {
  706.     SInt8                            ulpTimeoutValue;
  707.     SInt8                            ulpTimeoutAction;
  708.     SInt8                            validityFlags;
  709.     UInt8                            filler;                        /* Filler for proper byte alignment     */
  710.     Ptr                                userDataPtr;
  711. };
  712. typedef struct TCPClosePB TCPClosePB;
  713.  
  714. struct HistoBucket {
  715.     unsigned short                    value;
  716.     unsigned long                    counter;
  717. };
  718. typedef struct HistoBucket HistoBucket;
  719.  
  720.  
  721. enum {
  722.     NumOfHistoBuckets            = 7
  723. };
  724.  
  725. struct TCPConnectionStats {
  726.     unsigned long                    dataPktsRcvd;
  727.     unsigned long                    dataPktsSent;
  728.     unsigned long                    dataPktsResent;
  729.     unsigned long                    bytesRcvd;
  730.     unsigned long                    bytesRcvdDup;
  731.     unsigned long                    bytesRcvdPastWindow;
  732.     unsigned long                    bytesSent;
  733.     unsigned long                    bytesResent;
  734.     unsigned short                    numHistoBuckets;
  735.     struct HistoBucket                sentSizeHisto[NumOfHistoBuckets];
  736.     unsigned short                    lastRTT;
  737.     unsigned short                    tmrSRTT;
  738.     unsigned short                    rttVariance;
  739.     unsigned short                    tmrRTO;
  740.     SInt8                            sendTries;
  741.     SInt8                            sourchQuenchRcvd;
  742. };
  743. typedef struct TCPConnectionStats TCPConnectionStats;
  744.  
  745. struct TCPStatusPB {
  746.     SInt8                            ulpTimeoutValue;
  747.     SInt8                            ulpTimeoutAction;
  748.     long                            unused;
  749.     ip_addr                            remoteHost;
  750.     tcp_port                        remotePort;
  751.     ip_addr                            localHost;
  752.     tcp_port                        localPort;
  753.     SInt8                            tosFlags;
  754.     SInt8                            precedence;
  755.     SInt8                            connectionState;
  756.     UInt8                            filler;                        /* Filler for proper byte alignment     */
  757.     unsigned short                    sendWindow;
  758.     unsigned short                    rcvWindow;
  759.     unsigned short                    amtUnackedData;
  760.     unsigned short                    amtUnreadData;
  761.     Ptr                                securityLevelPtr;
  762.     unsigned long                    sendUnacked;
  763.     unsigned long                    sendNext;
  764.     unsigned long                    congestionWindow;
  765.     unsigned long                    rcvNext;
  766.     unsigned long                    srtt;
  767.     unsigned long                    lastRTT;
  768.     unsigned long                    sendMaxSegSize;
  769.     struct TCPConnectionStats        *connStatPtr;
  770.     Ptr                                userDataPtr;
  771. };
  772. typedef struct TCPStatusPB TCPStatusPB;
  773.  
  774. struct TCPAbortPB {
  775.     Ptr                                userDataPtr;
  776. };
  777. typedef struct TCPAbortPB TCPAbortPB;
  778.  
  779. struct TCPParam {
  780.     unsigned long                    tcpRtoA;
  781.     unsigned long                    tcpRtoMin;
  782.     unsigned long                    tcpRtoMax;
  783.     unsigned long                    tcpMaxSegSize;
  784.     unsigned long                    tcpMaxConn;
  785.     unsigned long                    tcpMaxWindow;
  786. };
  787. typedef struct TCPParam TCPParam;
  788.  
  789. struct TCPStats {
  790.     unsigned long                    tcpConnAttempts;
  791.     unsigned long                    tcpConnOpened;
  792.     unsigned long                    tcpConnAccepted;
  793.     unsigned long                    tcpConnClosed;
  794.     unsigned long                    tcpConnAborted;
  795.     unsigned long                    tcpOctetsIn;
  796.     unsigned long                    tcpOctetsOut;
  797.     unsigned long                    tcpOctetsInDup;
  798.     unsigned long                    tcpOctetsRetrans;
  799.     unsigned long                    tcpInputPkts;
  800.     unsigned long                    tcpOutputPkts;
  801.     unsigned long                    tcpDupPkts;
  802.     unsigned long                    tcpRetransPkts;
  803. };
  804. typedef struct TCPStats TCPStats;
  805.  
  806. typedef StreamPtr *StreamPPtr;
  807.  
  808. struct TCPGlobalInfoPB {
  809.     struct TCPParam                    *tcpParamPtr;
  810.     struct TCPStats                    *tcpStatsPtr;
  811.     StreamPPtr                        tcpCDBTable[1];
  812.     Ptr                                userDataPtr;
  813.     unsigned short                    maxTCPConnections;
  814. };
  815. typedef struct TCPGlobalInfoPB TCPGlobalInfoPB;
  816.  
  817. typedef void (*TCPIOCompletionProcPtr)(struct TCPiopb *iopb);
  818.  
  819. #if GENERATINGCFM
  820. typedef UniversalProcPtr TCPIOCompletionUPP;
  821. #else
  822. typedef TCPIOCompletionProcPtr TCPIOCompletionUPP;
  823. #endif
  824.  
  825. struct TCPiopb {
  826.     char                            fill12[12];
  827.     TCPIOCompletionUPP                ioCompletion;
  828.     short                            ioResult;
  829.     char                            *ioNamePtr;
  830.     short                            ioVRefNum;
  831.     short                            ioCRefNum;
  832.     short                            csCode;
  833.     StreamPtr                        tcpStream;
  834.         union {
  835.             struct TCPCreatePB                create;
  836.             struct TCPOpenPB                open;
  837.             struct TCPSendPB                send;
  838.             struct TCPReceivePB                receive;
  839.             struct TCPClosePB                close;
  840.             struct TCPAbortPB                abort;
  841.             struct TCPStatusPB                status;
  842.             struct TCPGlobalInfoPB            globalInfo;
  843.         }                            csParam;
  844. };
  845. typedef struct TCPiopb TCPiopb;
  846.  
  847.  
  848. #if GENERATINGCFM
  849. #else
  850. #endif
  851.  
  852. enum {
  853.     uppTCPIOCompletionProcInfo = kCStackBased
  854.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(struct TCPiopb*)))
  855. };
  856.  
  857. #if GENERATINGCFM
  858. #define NewTCPIOCompletionProc(userRoutine)        \
  859.         (TCPIOCompletionUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppTCPIOCompletionProcInfo, GetCurrentArchitecture())
  860. #else
  861. #define NewTCPIOCompletionProc(userRoutine)        \
  862.         ((TCPIOCompletionUPP) (userRoutine))
  863. #endif
  864.  
  865. #if GENERATINGCFM
  866. #define CallTCPIOCompletionProc(userRoutine, iopb)        \
  867.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppTCPIOCompletionProcInfo, (iopb))
  868. #else
  869. #define CallTCPIOCompletionProc(userRoutine, iopb)        \
  870.         (*(userRoutine))((iopb))
  871. #endif
  872.  
  873.  
  874. enum {
  875.     UDPCreate                    = 20,
  876.     UDPRead                        = 21,
  877.     UDPBfrReturn                = 22,
  878.     UDPWrite                    = 23,
  879.     UDPRelease                    = 24,
  880.     UDPMaxMTUSize                = 25,
  881.     UDPStatus                    = 26,
  882.     UDPMultiCreate                = 27,
  883.     UDPMultiSend                = 28,
  884.     UDPMultiRead                = 29,
  885.     UDPCtlMax                    = 29
  886. };
  887.  
  888. enum {
  889.     UDPDataArrival                = 1,
  890.     UDPICMPReceived                = 2
  891. };
  892.  
  893. typedef unsigned short UDPEventCode;
  894.  
  895. typedef pascal void (*UDPNotifyProcPtr)(StreamPtr udpStream, unsigned short eventCode, Ptr userDataPtr, struct ICMPReport *icmpMsg);
  896.  
  897. #if GENERATINGCFM
  898. typedef UniversalProcPtr UDPNotifyUPP;
  899. #else
  900. typedef UDPNotifyProcPtr UDPNotifyUPP;
  901. #endif
  902.  
  903. enum {
  904.     uppUDPNotifyProcInfo = kPascalStackBased
  905.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(StreamPtr)))
  906.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(unsigned short)))
  907.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(Ptr)))
  908.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(struct ICMPReport*)))
  909. };
  910.  
  911. #if GENERATINGCFM
  912. #define NewUDPNotifyProc(userRoutine)        \
  913.         (UDPNotifyUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppUDPNotifyProcInfo, GetCurrentArchitecture())
  914. #else
  915. #define NewUDPNotifyProc(userRoutine)        \
  916.         ((UDPNotifyUPP) (userRoutine))
  917. #endif
  918.  
  919. #if GENERATINGCFM
  920. #define CallUDPNotifyProc(userRoutine, udpStream, eventCode, userDataPtr, icmpMsg)        \
  921.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppUDPNotifyProcInfo, (udpStream), (eventCode), (userDataPtr), (icmpMsg))
  922. #else
  923. #define CallUDPNotifyProc(userRoutine, udpStream, eventCode, userDataPtr, icmpMsg)        \
  924.         (*(userRoutine))((udpStream), (eventCode), (userDataPtr), (icmpMsg))
  925. #endif
  926.  
  927. typedef unsigned short udp_port;
  928.  
  929. /* for create and release calls */
  930. struct UDPCreatePB {
  931.     Ptr                                rcvBuff;
  932.     unsigned long                    rcvBuffLen;
  933.     UDPNotifyUPP                    notifyProc;
  934.     unsigned short                    localPort;
  935.     Ptr                                userDataPtr;
  936.     udp_port                        endingPort;
  937. };
  938. typedef struct UDPCreatePB UDPCreatePB;
  939.  
  940. struct UDPSendPB {
  941.     unsigned short                    reserved;
  942.     ip_addr                            remoteHost;
  943.     udp_port                        remotePort;
  944.     Ptr                                wdsPtr;
  945.     Boolean                            checkSum;
  946.     UInt8                            filler;                        /* Filler for proper byte alignment     */
  947.     unsigned short                    sendLength;
  948.     Ptr                                userDataPtr;
  949.     udp_port                        localPort;
  950. };
  951. typedef struct UDPSendPB UDPSendPB;
  952.  
  953. /* for receive and buffer return calls */
  954. struct UDPReceivePB {
  955.     unsigned short                    timeOut;
  956.     ip_addr                            remoteHost;
  957.     udp_port                        remotePort;
  958.     Ptr                                rcvBuff;
  959.     unsigned short                    rcvBuffLen;
  960.     unsigned short                    secondTimeStamp;
  961.     Ptr                                userDataPtr;
  962.     ip_addr                            destHost;                    /* only for use with multi rcv */
  963.     udp_port                        destPort;                    /* only for use with multi rcv */
  964. };
  965. typedef struct UDPReceivePB UDPReceivePB;
  966.  
  967. struct UDPMTUPB {
  968.     unsigned short                    mtuSize;
  969.     ip_addr                            remoteHost;
  970.     Ptr                                userDataPtr;
  971. };
  972. typedef void (*UDPIOCompletionProcPtr)(struct UDPiopb *iopb);
  973.  
  974. #if GENERATINGCFM
  975. typedef UniversalProcPtr UDPIOCompletionUPP;
  976. #else
  977. typedef UDPIOCompletionProcPtr UDPIOCompletionUPP;
  978. #endif
  979.  
  980. typedef struct UDPMTUPB UDPMTUPB;
  981.  
  982. struct UDPiopb {
  983.     char                            fill12[12];
  984.     UDPIOCompletionUPP                ioCompletion;
  985.     short                            ioResult;
  986.     char                            *ioNamePtr;
  987.     short                            ioVRefNum;
  988.     short                            ioCRefNum;
  989.     short                            csCode;
  990.     StreamPtr                        udpStream;
  991.         union {
  992.             struct UDPCreatePB                create;
  993.             struct UDPSendPB                send;
  994.             struct UDPReceivePB                receive;
  995.             struct UDPMTUPB                    mtu;
  996.         }                            csParam;
  997. };
  998. typedef struct UDPiopb UDPiopb;
  999.  
  1000.  
  1001. #ifdef __CFM68K__
  1002. #pragma lib_export off
  1003. #endif
  1004.  
  1005. #if GENERATINGPOWERPC
  1006. #pragma options align=reset
  1007. #endif
  1008.  
  1009. #ifdef __cplusplus
  1010. }
  1011. #endif
  1012.  
  1013. #endif /* __MACTCP__ */
  1014.